// 豆包平台适配器

class DouBaoCollector extends DataCollector {
  constructor() {
    super('DouBao');
    
    // 豆包特定的选择器（基于实际页面）
    this.selectors = {
      chatContainer: 'main',
      userMessage: '[data-testid="send_message"]',  // 用户消息
      aiMessage: '[data-testid="receive_message"]',  // AI消息
      messageContent: '[data-testid="message_text_content"]',  // 消息文本内容
      inputBox: 'textarea[data-testid="chat_input_input"]',  // 输入框（精确）
      sendButton: 'button[data-testid="chat_input_send_button"]',  // 发送按钮
      sendButtonAlt: '#flow-end-msg-send',  // 备用选择器
      userAvatar: '[class*="avatar"], .user-info',  // 用户头像
      generating: '[class*="generating"], [class*="typing"], [class*="streaming"], [data-generating="true"]'
    };
  }

  getTargetNode() {
    return document.querySelector(this.selectors.chatContainer) || document.body;
  }

  handleDOMChange(mutations) {
    if (!this.isCollecting) return;

    for (const mutation of mutations) {
      for (const node of mutation.addedNodes) {
        if (node.nodeType === 1) {
          
          // 方法1：检查节点本身是否是AI消息
          if (node.matches && node.matches(this.selectors.aiMessage)) {
            // 立即设置标记，防止重复
            if (node.dataset.collected === 'true') {
              continue;
            }
            node.dataset.collected = 'true';
            
            console.log('[DouBao] DOM变化：检测到AI消息（直接节点）');
            this.handleNewAIMessage(node);
            return;
          }
          
          // 方法2：检查子节点中是否有AI消息
          const aiMessages = node.querySelectorAll?.(this.selectors.aiMessage);
          if (aiMessages && aiMessages.length > 0) {
            const lastAiMsg = aiMessages[aiMessages.length - 1];
            // 立即设置标记，防止重复
            if (lastAiMsg.dataset.collected === 'true') {
              continue;
            }
            lastAiMsg.dataset.collected = 'true';
            
            console.log('[DouBao] DOM变化：检测到AI消息（子节点）');
            this.handleNewAIMessage(lastAiMsg);
            return;
          }
          
          // 方法3：检查是否是消息内容更新
          if (node.matches && node.matches(this.selectors.messageContent)) {
            const messageParent = node.closest(this.selectors.aiMessage);
            if (messageParent) {
              // 立即设置标记，防止重复
              if (messageParent.dataset.collected === 'true') {
                continue;
              }
              messageParent.dataset.collected = 'true';
              
              console.log('[DouBao] DOM变化：消息内容更新');
              this.handleNewAIMessage(messageParent);
              return;
            }
          }
        }
      }
    }
  }

  async handleNewAIMessage(element) {
    // 标记已在 handleDOMChange 中设置，这里只做二次检查
    if (element.dataset.collected !== 'true') {
      element.dataset.collected = 'true';
    }

    console.log('[DouBao] 检测到新的AI消息');

    await this.waitForMessageComplete(element);

    console.log('[DouBao] AI消息已完成，开始提取数据');

    const conversation = this.extractConversation();
    if (conversation) {
      console.log('[DouBao] 数据提取成功，准备保存');
      await this.saveData(conversation);
    } else {
      console.warn('[DouBao] 数据提取失败');
    }
  }

  async waitForMessageComplete(element, maxWait = 180000) {  // 增加到3分钟
    const startTime = Date.now();
    
    console.log('[DouBao] 开始等待消息生成完成...');
    console.log('[DouBao] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2;
    
    console.log(`[DouBao] 配置：内容稳定 ${waitSeconds} 秒后采集`);
    
    return new Promise((resolve) => {
      let lastContent = '';
      let stableCount = 0;
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每10秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 10 === 0 && elapsed % 1000 < 500) {
          console.log(`[DouBao] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((maxWait - elapsed) / 1000)} 秒`);
        }
        
        // 检查内容是否还在变化
        const currentContent = this.extractMessageContent(element);
        const contentStable = currentContent === lastContent;
        
        if (contentStable) {
          stableCount++;
          console.log(`[DouBao] 内容稳定计数: ${stableCount}/${requiredStableChecks}`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log('[DouBao] 内容还在变化，长度:', currentContent.length);
        }
        
        // 检查是否还在生成
        const isGenerating = document.querySelector(this.selectors.generating);
        
        // 防止过早采集：如果内容太短（<20字符）且在2分钟内，继续等待
        const isTooShort = currentContent.length < 20;
        const withinTimeLimit = elapsed < 120000;  // 2分钟
        
        if (isTooShort && withinTimeLimit && stableCount >= requiredStableChecks) {
          console.log(`[DouBao] ⚠️ 内容太短（${currentContent.length}字符），继续等待...`);
          stableCount = 0;  // 重置计数，继续等待
          return;
        }
        
        // 完成条件
        if ((stableCount >= requiredStableChecks && !isGenerating) || elapsed > maxWait) {
          clearInterval(checkInterval);
          
          if (elapsed > maxWait) {
            const totalSeconds = Math.floor(elapsed / 1000);
            console.warn(`[DouBao] ⚠️ 等待超时（${totalSeconds}秒），强制采集`);
            console.warn('[DouBao] 当前内容长度:', currentContent.length);
            if (currentContent.length === 0) {
              console.error('[DouBao] ❌ 超时且无内容，可能采集失败');
            }
          } else {
            const totalSeconds = Math.floor(elapsed / 1000);
            console.log(`[DouBao] ✅ 消息生成完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          }
          
          resolve();
        }
      }, 500);
    });
  }

  extractConversation() {
    try {
      console.log('[DouBao] 开始提取对话...');
      
      // 获取所有用户和AI消息
      const userMessages = Array.from(document.querySelectorAll(this.selectors.userMessage));
      const aiMessages = Array.from(document.querySelectorAll(this.selectors.aiMessage));

      console.log('[DouBao] 用户消息数:', userMessages.length);
      console.log('[DouBao] AI消息数:', aiMessages.length);

      if (userMessages.length === 0 || aiMessages.length === 0) {
        console.warn('[DouBao] 消息数量不足');
        return null;
      }

      // 获取最后一对对话
      const lastUserMsg = userMessages[userMessages.length - 1];
      const lastAiMsg = aiMessages[aiMessages.length - 1];

      // 提取内容（豆包的内容在 message_text_content 中）
      const userContent = this.extractMessageContent(lastUserMsg);
      const aiContent = this.extractMessageContent(lastAiMsg);

      console.log('[DouBao] 用户消息:', userContent.substring(0, 50));
      console.log('[DouBao] AI回答:', aiContent.substring(0, 100));

      if (!userContent || !aiContent) {
        console.warn('[DouBao] 内容为空');
        return null;
      }

      // 同时提取HTML格式
      const aiHTML = this.extractMessageHTML(lastAiMsg);
      
      return {
        userMessage: userContent,
        aiResponse: aiContent,
        aiResponseHTML: aiHTML  // 保留原始HTML格式
      };
    } catch (e) {
      console.error('[DouBao] 提取对话失败:', e);
      return null;
    }
  }
  
  // 提取消息内容（豆包特殊处理）
  extractMessageContent(messageElement) {
    if (!messageElement) return '';
    
    // 豆包的消息内容在 message_text_content 中
    const textContent = messageElement.querySelector(this.selectors.messageContent);
    
    if (textContent) {
      // 使用 innerText 保留格式，去除HTML
      return textContent.innerText || textContent.textContent || '';
    }
    
    // 备用方案：使用整个消息元素
    return messageElement.innerText || messageElement.textContent || '';
  }
  
  // 提取消息HTML格式（保留完整格式）
  extractMessageHTML(messageElement) {
    if (!messageElement) return '';
    
    // 豆包的消息内容在 message_text_content 中
    const textContent = messageElement.querySelector(this.selectors.messageContent);
    
    if (textContent) {
      // 克隆元素，保留完整格式
      const cloned = textContent.cloneNode(true);
      
      // 可以在这里清理不需要的元素（如果有）
      // const unwanted = cloned.querySelectorAll('.unwanted-class');
      // unwanted.forEach(el => el.remove());
      
      // 返回HTML
      return cloned.innerHTML;
    }
    
    // 备用方案
    return messageElement.innerHTML || '';
  }

  async sendMessage(text) {
    try {
      console.log('\n========== [DouBao] 开始发送消息 ==========');
      console.log('[DouBao] 消息内容:', text);
      console.log('[DouBao] 消息长度:', text.length);
      console.log('[DouBao] 当前页面URL:', window.location.href);
      console.log('[DouBao] 当前页面标题:', document.title);
      console.log('[DouBao] 页面是否可见:', document.visibilityState);
      
      // 1. 找到输入框
      console.log('[DouBao] 步骤1: 查找输入框，选择器:', this.selectors.inputBox);
      const inputBox = await this.waitForElement(this.selectors.inputBox);
      console.log('[DouBao] ✅ 找到输入框:', inputBox);
      console.log('[DouBao] 输入框当前值:', inputBox.value);
      console.log('[DouBao] 输入框是否禁用:', inputBox.disabled);
      
      // 2. 清空并聚焦
      console.log('[DouBao] 步骤2: 清空并聚焦输入框');
      inputBox.value = '';
      inputBox.focus();
      console.log('[DouBao] ✅ 输入框已聚焦');
      
      // 3. 输入文本
      console.log('[DouBao] 步骤3: 输入文本');
      inputBox.value = text;
      
      // 触发输入事件（豆包需要这些事件来启用发送按钮）
      ['input', 'change', 'keyup', 'keydown'].forEach(eventType => {
        const event = new Event(eventType, { bubbles: true, cancelable: true });
        inputBox.dispatchEvent(event);
      });
      
      console.log('[DouBao] ✅ 文本已输入:', text.substring(0, 50) + (text.length > 50 ? '...' : ''));
      console.log('[DouBao] 输入框最终值:', inputBox.value.substring(0, 50) + (inputBox.value.length > 50 ? '...' : ''));
      
      // 4. 等待发送按钮启用（重要！）
      // 豆包的发送按钮初始是disabled的，输入内容后才会启用
      console.log('[DouBao] 等待UI更新 (800ms)...');
      await new Promise(resolve => setTimeout(resolve, 800));
      
      // 5. 查找发送按钮
      console.log('[DouBao] 步骤4: 查找发送按钮');
      console.log('[DouBao] 主选择器:', this.selectors.sendButton);
      console.log('[DouBao] 备用选择器:', this.selectors.sendButtonAlt);
      
      let sendButton = document.querySelector(this.selectors.sendButton);
      
      if (!sendButton) {
        console.log('[DouBao] 主选择器未找到，尝试备用选择器...');
        sendButton = document.querySelector(this.selectors.sendButtonAlt);
      }
      
      if (!sendButton) {
        console.error('[DouBao] ❌ 未找到发送按钮');
        console.error('[DouBao] 页面所有button:', document.querySelectorAll('button').length);
        console.error('[DouBao] 页面所有包含send的元素:', document.querySelectorAll('[id*="send"], [class*="send"]').length);
        throw new Error('未找到发送按钮');
      }
      
      console.log('[DouBao] ✅ 找到发送按钮:', sendButton);
      console.log('[DouBao] 按钮标签:', sendButton.tagName);
      console.log('[DouBao] 按钮ID:', sendButton.id);
      console.log('[DouBao] 按钮class:', sendButton.className);
      console.log('[DouBao] 按钮disabled:', sendButton.disabled);
      console.log('[DouBao] 按钮aria-disabled:', sendButton.getAttribute('aria-disabled'));
      
      // 6. 检查按钮是否已启用
      if (sendButton.disabled || sendButton.getAttribute('aria-disabled') === 'true') {
        console.warn('[DouBao] ⚠️ 发送按钮仍然是禁用状态，再等待一下...');
        await new Promise(resolve => setTimeout(resolve, 500));
        console.log('[DouBao] 等待后的按钮状态 - disabled:', sendButton.disabled, 'aria-disabled:', sendButton.getAttribute('aria-disabled'));
      }
      
      // 7. 点击发送按钮
      console.log('[DouBao] 步骤5: 点击发送按钮');
      sendButton.click();
      console.log('[DouBao] ✅ 已执行 click()');
      
      // 也触发鼠标事件
      ['mousedown', 'mouseup', 'click'].forEach(eventType => {
        const event = new MouseEvent(eventType, {
          bubbles: true,
          cancelable: true,
          view: window
        });
        sendButton.dispatchEvent(event);
      });
      console.log('[DouBao] ✅ 已触发鼠标事件 (mousedown, mouseup, click)');
      
      console.log('[DouBao] 等待消息发送 (500ms)...');
      await new Promise(resolve => setTimeout(resolve, 500));
      
      console.log('[DouBao] ========== 消息发送完成 ==========\n');
    } catch (e) {
      console.error('[DouBao] 发送消息失败:', e);
      console.error('[DouBao] 错误堆栈:', e.stack);
      throw e;
    }
  }

  async waitForResponse(timeout = 180000) {  // 增加到3分钟
    const startTime = Date.now();
    
    console.log('[DouBao] 等待AI响应...');
    console.log('[DouBao] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2;
    
    console.log(`[DouBao] 配置：内容稳定 ${waitSeconds} 秒后完成`);
    
    return new Promise((resolve, reject) => {
      let lastContent = '';
      let stableCount = 0;
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每15秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 15 === 0 && elapsed % 1000 < 500) {
          console.log(`[DouBao] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((timeout - elapsed) / 1000)} 秒`);
        }
        
        // 获取所有AI消息
        const aiMessages = document.querySelectorAll(this.selectors.aiMessage);
        
        if (aiMessages.length === 0) {
          if (elapsedSeconds > 30) {
            console.warn('[DouBao] ⚠️ 等待超过30秒仍无响应...');
          }
          return;
        }
        
        const lastAiMessage = aiMessages[aiMessages.length - 1];
        const currentContent = this.extractMessageContent(lastAiMessage);
        
        if (currentContent === lastContent) {
          stableCount++;
          console.log(`[DouBao] 响应内容稳定: ${stableCount}/${requiredStableChecks}`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log(`[DouBao] 响应内容更新: ${currentContent.length} 字符`);
        }
        
        // 检查是否还在生成
        const isGenerating = document.querySelector(this.selectors.generating);
        
        // 防止过早采集：如果内容太短且在时间限制内，继续等待
        const isTooShort = currentContent.length < 20;
        const withinTimeLimit = elapsed < 120000;  // 2分钟
        
        if (isTooShort && withinTimeLimit && stableCount >= requiredStableChecks) {
          console.log(`[DouBao] ⚠️ 响应内容太短（${currentContent.length}字符），继续等待...`);
          stableCount = 0;  // 重置，继续等待
          return;
        }
        
        // 完成条件
        if (stableCount >= requiredStableChecks && !isGenerating) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.log(`[DouBao] ✅ 响应完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          resolve();
        }
        
        if (elapsed > timeout) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.warn(`[DouBao] ⚠️ 等待响应超时（${totalSeconds}秒）`);
          console.warn('[DouBao] 当前内容长度:', currentContent.length);
          
          // 如果有内容就resolve，没内容就reject
          if (currentContent.length > 0) {
            console.warn('[DouBao] 有部分内容，继续采集');
            resolve();
          } else {
            console.error('[DouBao] ❌ 超时且无内容，采集失败');
            reject(new Error('等待响应超时且无内容'));
          }
        }
      }, 500);
    });
  }

  getLatestResponse() {
    const aiMessages = document.querySelectorAll(this.selectors.aiMessage);
    if (aiMessages.length === 0) return null;
    
    const lastMessage = aiMessages[aiMessages.length - 1];
    return this.extractMessageContent(lastMessage);
  }

  isLoggedIn() {
    // 方法1：检查URL
    const url = window.location.href;
    if (url.includes('login') || url.includes('sign')) {
      return false;
    }
    
    // 方法2：检查输入框是否存在（已登录才有）
    const inputBox = document.querySelector(this.selectors.inputBox);
    if (inputBox) {
      console.log('[DouBao] 检测到输入框，判断为已登录');
      return true;
    }
    
    // 方法3：检查是否有头像或用户信息
    const userAvatar = document.querySelector(this.selectors.userAvatar);
    if (userAvatar) {
      return true;
    }
    
    // 方法4：检查页面标题或特征元素
    const hasSkillBar = document.querySelector('[data-component-type="skill-item"]') !== null;
    if (hasSkillBar) {
      console.log('[DouBao] 检测到技能栏，判断为已登录');
      return true;
    }
    
    // 默认：如果在豆包域名且不在登录页，认为已登录
    return url.includes('doubao.com') && !url.includes('login');
  }
}

const collector = new DouBaoCollector();
collector.init();

console.log('[DouBao] ========== 内容脚本已加载 ==========');
console.log('[DouBao] 当前页面URL:', window.location.href);
console.log('[DouBao] 页面标题:', document.title);
console.log('[DouBao] 消息监听器已注册');
console.log('[DouBao] 等待接收sendMessage请求...');

